package nav

/*
#include<stdint.h>
#include<stdbool.h>
extern unsigned int nav_dtNavMeshQuery_closestPointOnPoly(void * c_this,unsigned int ref,void * pos,void * closest,void * posOverPoly);
extern unsigned int nav_dtNavMeshQuery_closestPointOnPolyBoundary(void * c_this,unsigned int ref,void * pos,void * closest);
extern void nav_dtNavMeshQuery_Delete(void * c_this);
extern void nav_dtNavMeshQuery_DeleteArray(void * c_this);
extern void* nav_NewdtNavMeshQuery();
extern unsigned int nav_dtNavMeshQuery_finalizeSlicedFindPath(void * c_this,void * path,void * pathCount,int maxPath);
extern unsigned int nav_dtNavMeshQuery_finalizeSlicedFindPathPartial(void * c_this,void * existing,int existingSize,void * path,void * pathCount,int maxPath);
extern unsigned int nav_dtNavMeshQuery_findDistanceToWall(void * c_this,unsigned int startRef,void * centerPos,float maxRadius,void * filter,void * hitDist,void * hitPos,void * hitNormal);
extern unsigned int nav_dtNavMeshQuery_findLocalNeighbourhood(void * c_this,unsigned int startRef,void * centerPos,float radius,void * filter,void * resultRef,void * resultParent,void * resultCount,int maxResult);
extern unsigned int nav_dtNavMeshQuery_findNearestPoly(void * c_this,void * center,void * halfExtents,void * filter,void * nearestRef,void * nearestPt);
extern unsigned int nav_dtNavMeshQuery_findNearestPoly11(void * c_this,void * center,void * halfExtents,void * filter,void * nearestRef,void * nearestPt,void * isOverPoly);
extern unsigned int nav_dtNavMeshQuery_findPath(void * c_this,unsigned int startRef,unsigned int endRef,void * startPos,void * endPos,void * filter,void * path,void * pathCount,int maxPath);
extern unsigned int nav_dtNavMeshQuery_findPolysAroundCircle(void * c_this,unsigned int startRef,void * centerPos,float radius,void * filter,void * resultRef,void * resultParent,void * resultCost,void * resultCount,int maxResult);
extern unsigned int nav_dtNavMeshQuery_findPolysAroundShape(void * c_this,unsigned int startRef,void * verts,int nverts,void * filter,void * resultRef,void * resultParent,void * resultCost,void * resultCount,int maxResult);
extern unsigned int nav_dtNavMeshQuery_findStraightPath(void * c_this,void * startPos,void * endPos,void * path,int pathSize,void * straightPath,void * straightPathFlags,void * straightPathRefs,void * straightPathCount,int maxStraightPath,int options);
extern void * nav_dtNavMeshQuery_getAttachedNavMesh(void * c_this);
extern void * nav_dtNavMeshQuery_getNodePool(void * c_this);
extern unsigned int nav_dtNavMeshQuery_getPathFromDijkstraSearch(void * c_this,unsigned int endRef,void * path,void * pathCount,int maxPath);
extern unsigned int nav_dtNavMeshQuery_getPolyHeight(void * c_this,unsigned int ref,void * pos,void * height);
extern unsigned int nav_dtNavMeshQuery_getPolyWallSegments(void * c_this,unsigned int ref,void * filter,void * segmentVerts,void * segmentRefs,void * segmentCount,int maxSegments);
extern void * nav_dtNavMeshQuery_IndexArray(void * c_this,long n);
extern unsigned int nav_dtNavMeshQuery_init(void * c_this,void * tmp_arg_nav,int maxNodes);
extern unsigned int nav_dtNavMeshQuery_initSlicedFindPath(void * c_this,unsigned int startRef,unsigned int endRef,void * startPos,void * endPos,void * filter,unsigned int options);
extern bool nav_dtNavMeshQuery_isInClosedList(void * c_this,unsigned int ref);
extern bool nav_dtNavMeshQuery_isValidPolyRef(void * c_this,unsigned int ref,void * filter);
extern unsigned int nav_dtNavMeshQuery_moveAlongSurface(void * c_this,unsigned int startRef,void * startPos,void * endPos,void * filter,void * resultPos,void * visited,void * visitedCount,int maxVisitedSize);
extern unsigned int nav_dtNavMeshQuery_queryPolygons(void * c_this,void * center,void * halfExtents,void * filter,void * polys,void * polyCount,int maxPolys);
extern unsigned int nav_dtNavMeshQuery_queryPolygons11(void * c_this,void * center,void * halfExtents,void * filter,void * query);
extern unsigned int nav_dtNavMeshQuery_raycast(void * c_this,unsigned int startRef,void * startPos,void * endPos,void * filter,void * t,void * hitNormal,void * path,void * pathCount,int maxPath);
extern unsigned int nav_dtNavMeshQuery_raycast11(void * c_this,unsigned int startRef,void * startPos,void * endPos,void * filter,unsigned int options,void * hit,unsigned int prevRef);
extern unsigned int nav_dtNavMeshQuery_updateSlicedFindPath(void * c_this,int maxIter,void * doneIters);
extern void nav_dtPolyQuery_Delete(void * c_this);
extern void nav_dtPolyQuery_process(void * c_this,void * tile,void * polys,void * refs,int count);
extern void nav_dtQueryFilter_Delete(void * c_this);
extern void nav_dtQueryFilter_DeleteArray(void * c_this);
extern void* nav_NewdtQueryFilter();
extern float nav_dtQueryFilter_getAreaCost(void * c_this,int i);
extern float nav_dtQueryFilter_getCost(void * c_this,void * pa,void * pb,unsigned int prevRef,void * prevTile,void * prevPoly,unsigned int curRef,void * curTile,void * curPoly,unsigned int nextRef,void * nextTile,void * nextPoly);
extern unsigned short nav_dtQueryFilter_getExcludeFlags(void * c_this);
extern unsigned short nav_dtQueryFilter_getIncludeFlags(void * c_this);
extern void * nav_dtQueryFilter_IndexArray(void * c_this,long n);
extern bool nav_dtQueryFilter_passFilter(void * c_this,unsigned int ref,void * tile,void * poly);
extern void nav_dtQueryFilter_setAreaCost(void * c_this,int i,float cost);
extern void nav_dtQueryFilter_setExcludeFlags(void * c_this,unsigned short flags);
extern void nav_dtQueryFilter_setIncludeFlags(void * c_this,unsigned short flags);
extern void nav_dtRaycastHit_Delete(void * c_this);
extern void nav_dtRaycastHit_DeleteArray(void * c_this);
extern void* nav_NewdtRaycastHit();
extern void * nav_dtRaycastHit_GetPtrToHitEdgeIndex(void * c_this);
extern void * nav_dtRaycastHit_GetPtrToHitNormal(void * c_this);
extern void * nav_dtRaycastHit_GetPtrToMaxPath(void * c_this);
extern void * nav_dtRaycastHit_GetPtrToPath(void * c_this);
extern void * nav_dtRaycastHit_GetPtrToPathCost(void * c_this);
extern void * nav_dtRaycastHit_GetPtrToPathCount(void * c_this);
extern void * nav_dtRaycastHit_GetPtrToT(void * c_this);
extern void * nav_dtRaycastHit_IndexArray(void * c_this,long n);
extern void * nav_dtAllocNavMeshQuery();
extern void nav_dtFreeNavMeshQuery(void * query);
extern void * nav_NewDtNavMeshQueryPtrArray(long n);
extern void * nav_NewDtQueryFilterPtrArray(long n);
extern void * nav_NewDtRaycastHitPtrArray(long n);

*/
import "C"
import "unsafe"
import "gitee.com/hasika/cgo"

var _ unsafe.Pointer
var _ cgo.NotUsed

/*
Provides the ability to perform pathfinding related queries against
a navigation mesh.

	detour
*/
type DtNavMeshQueryPtr uintptr

/*
Finds the closest point on the specified polygon.

@param ref The reference id of the polygon.
@param pos The position to check. [(x, y, z)]
@param closest The closest point on the polygon. [(x, y, z)]
@param posOverPoly True of the position is over the polygon.
@returns The status flags for the query.

public dtStatus closestPointOnPoly(dtPolyRef ref, float const * pos, float * closest, bool * posOverPoly) const
*/
func (p DtNavMeshQueryPtr) ClosestPointOnPoly(ref uint32, pos *float32, closest *float32, posOverPoly *bool) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_pos unsafe.Pointer
	var wrap_arg_closest unsafe.Pointer
	var wrap_arg_posOverPoly unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_pos = (unsafe.Pointer)(pos)
	wrap_arg_closest = (unsafe.Pointer)(closest)
	wrap_arg_posOverPoly = (unsafe.Pointer)(posOverPoly)
	wrap_out := C.nav_dtNavMeshQuery_closestPointOnPoly(wrap_this, wrap_arg_ref, wrap_arg_pos, wrap_arg_closest, wrap_arg_posOverPoly)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Returns a point on the boundary closest to the source point if the source point is outside the
polygon's xz-bounds.

@param ref The reference id to the polygon.
@param pos The position to check. [(x, y, z)]
@param closest The closest point. [(x, y, z)]
@returns The status flags for the query.

public dtStatus closestPointOnPolyBoundary(dtPolyRef ref, float const * pos, float * closest) const
*/
func (p DtNavMeshQueryPtr) ClosestPointOnPolyBoundary(ref uint32, pos *float32, closest *float32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_pos unsafe.Pointer
	var wrap_arg_closest unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_pos = (unsafe.Pointer)(pos)
	wrap_arg_closest = (unsafe.Pointer)(closest)
	wrap_out := C.nav_dtNavMeshQuery_closestPointOnPolyBoundary(wrap_this, wrap_arg_ref, wrap_arg_pos, wrap_arg_closest)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public void Delete()
*/
func (p DtNavMeshQueryPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtNavMeshQuery_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtNavMeshQueryPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtNavMeshQuery_DeleteArray(wrap_this)
}

/*
public dtNavMeshQuery()
*/
func NewDtNavMeshQuery() cgo.GoManagedPtr[DtNavMeshQueryPtr] {
	wrap_out := C.nav_NewdtNavMeshQuery()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtNavMeshQueryPtr]](uintptr(wrap_out))
	return go_out
}

/*
Finalizes and returns the results of a sliced path query.

@param path An ordered list of polygon references representing the path. (Start to end.)
[(polyRef) * @p pathCount]
@param pathCount The number of polygons returned in the @p path array.
@param maxPath The max number of polygons the path array can hold. [Limit: >= 1]
@returns The status flags for the query.

public dtStatus finalizeSlicedFindPath(dtPolyRef * path, int * pathCount, int const maxPath)
*/
func (p DtNavMeshQueryPtr) FinalizeSlicedFindPath(path *uint32, pathCount *int32, maxPath int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_path unsafe.Pointer
	var wrap_arg_pathCount unsafe.Pointer
	var wrap_arg_maxPath C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_path = (unsafe.Pointer)(path)
	wrap_arg_pathCount = (unsafe.Pointer)(pathCount)
	wrap_arg_maxPath = (C.int)(maxPath)
	wrap_out := C.nav_dtNavMeshQuery_finalizeSlicedFindPath(wrap_this, wrap_arg_path, wrap_arg_pathCount, wrap_arg_maxPath)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Finalizes and returns the results of an incomplete sliced path query, returning the path to the furthest
polygon on the existing path that was visited during the search.

@param existing An array of polygon references for the existing path.
@param existingSize The number of polygon in the @p existing array.
@param path An ordered list of polygon references representing the path. (Start to end.)
[(polyRef) * @p pathCount]
@param pathCount The number of polygons returned in the @p path array.
@param maxPath The max number of polygons the @p path array can hold. [Limit: >= 1]
@returns The status flags for the query.

public dtStatus finalizeSlicedFindPathPartial(dtPolyRef const * existing, int const existingSize, dtPolyRef * path, int * pathCount, int const maxPath)
*/
func (p DtNavMeshQueryPtr) FinalizeSlicedFindPathPartial(existing *uint32, existingSize int32, path *uint32, pathCount *int32, maxPath int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_existing unsafe.Pointer
	var wrap_arg_existingSize C.int
	var wrap_arg_path unsafe.Pointer
	var wrap_arg_pathCount unsafe.Pointer
	var wrap_arg_maxPath C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_existing = (unsafe.Pointer)(existing)
	wrap_arg_existingSize = (C.int)(existingSize)
	wrap_arg_path = (unsafe.Pointer)(path)
	wrap_arg_pathCount = (unsafe.Pointer)(pathCount)
	wrap_arg_maxPath = (C.int)(maxPath)
	wrap_out := C.nav_dtNavMeshQuery_finalizeSlicedFindPathPartial(wrap_this, wrap_arg_existing, wrap_arg_existingSize, wrap_arg_path, wrap_arg_pathCount, wrap_arg_maxPath)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Finds the distance from the specified position to the nearest polygon wall.

@param startRef The reference id of the polygon containing @p centerPos.
@param centerPos The center of the search circle. [(x, y, z)]
@param maxRadius The radius of the search circle.
@param filter The polygon filter to apply to the query.
@param hitDist The distance to the nearest wall from @p centerPos.
@param hitPos The nearest position on the wall that was hit. [(x, y, z)]
@param hitNormal The normalized ray formed from the wall point to the
source point. [(x, y, z)]
@returns The status flags for the query.

public dtStatus findDistanceToWall(dtPolyRef startRef, float const * centerPos, float const maxRadius, dtQueryFilter const * filter, float * hitDist, float * hitPos, float * hitNormal) const
*/
func (p DtNavMeshQueryPtr) FindDistanceToWall(startRef uint32, centerPos *float32, maxRadius float32, filter DtQueryFilterPtr, hitDist *float32, hitPos *float32, hitNormal *float32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_startRef C.uint
	var wrap_arg_centerPos unsafe.Pointer
	var wrap_arg_maxRadius C.float
	var wrap_arg_filter unsafe.Pointer
	var wrap_arg_hitDist unsafe.Pointer
	var wrap_arg_hitPos unsafe.Pointer
	var wrap_arg_hitNormal unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_startRef = (C.uint)(startRef)
	wrap_arg_centerPos = (unsafe.Pointer)(centerPos)
	wrap_arg_maxRadius = (C.float)(maxRadius)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_arg_hitDist = (unsafe.Pointer)(hitDist)
	wrap_arg_hitPos = (unsafe.Pointer)(hitPos)
	wrap_arg_hitNormal = (unsafe.Pointer)(hitNormal)
	wrap_out := C.nav_dtNavMeshQuery_findDistanceToWall(wrap_this, wrap_arg_startRef, wrap_arg_centerPos, wrap_arg_maxRadius, wrap_arg_filter, wrap_arg_hitDist, wrap_arg_hitPos, wrap_arg_hitNormal)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Finds the non-overlapping navigation polygons in the local neighbourhood around the center position.

@param startRef The reference id of the polygon where the search starts.
@param centerPos The center of the query circle. [(x, y, z)]
@param radius The radius of the query circle.
@param filter The polygon filter to apply to the query.
@param resultRef The reference ids of the polygons touched by the circle.
@param resultParent The reference ids of the parent polygons for each result.
Zero if a result polygon has no parent. [opt]
@param resultCount The number of polygons found.
@param maxResult The maximum number of polygons the result arrays can hold.
@returns The status flags for the query.

public dtStatus findLocalNeighbourhood(dtPolyRef startRef, float const * centerPos, float const radius, dtQueryFilter const * filter, dtPolyRef * resultRef, dtPolyRef * resultParent, int * resultCount, int const maxResult) const
*/
func (p DtNavMeshQueryPtr) FindLocalNeighbourhood(startRef uint32, centerPos *float32, radius float32, filter DtQueryFilterPtr, resultRef *uint32, resultParent *uint32, resultCount *int32, maxResult int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_startRef C.uint
	var wrap_arg_centerPos unsafe.Pointer
	var wrap_arg_radius C.float
	var wrap_arg_filter unsafe.Pointer
	var wrap_arg_resultRef unsafe.Pointer
	var wrap_arg_resultParent unsafe.Pointer
	var wrap_arg_resultCount unsafe.Pointer
	var wrap_arg_maxResult C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_startRef = (C.uint)(startRef)
	wrap_arg_centerPos = (unsafe.Pointer)(centerPos)
	wrap_arg_radius = (C.float)(radius)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_arg_resultRef = (unsafe.Pointer)(resultRef)
	wrap_arg_resultParent = (unsafe.Pointer)(resultParent)
	wrap_arg_resultCount = (unsafe.Pointer)(resultCount)
	wrap_arg_maxResult = (C.int)(maxResult)
	wrap_out := C.nav_dtNavMeshQuery_findLocalNeighbourhood(wrap_this, wrap_arg_startRef, wrap_arg_centerPos, wrap_arg_radius, wrap_arg_filter, wrap_arg_resultRef, wrap_arg_resultParent, wrap_arg_resultCount, wrap_arg_maxResult)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Finds the polygon nearest to the specified center point.
[opt] means the specified parameter can be a null pointer, in that case the output parameter will not be set.

@param center The center of the search box. [(x, y, z)]
@param halfExtents The search distance along each axis. [(x, y, z)]
@param filter The polygon filter to apply to the query.
@param nearestRef The reference id of the nearest polygon. Will be set to 0 if no polygon is found.
@param nearestPt The nearest point on the polygon. Unchanged if no polygon is found. [opt] [(x, y, z)]
@returns The status flags for the query.

public dtStatus findNearestPoly(float const * center, float const * halfExtents, dtQueryFilter const * filter, dtPolyRef * nearestRef, float * nearestPt) const
*/
func (p DtNavMeshQueryPtr) FindNearestPoly(center *float32, halfExtents *float32, filter DtQueryFilterPtr, nearestRef *uint32, nearestPt *float32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_center unsafe.Pointer
	var wrap_arg_halfExtents unsafe.Pointer
	var wrap_arg_filter unsafe.Pointer
	var wrap_arg_nearestRef unsafe.Pointer
	var wrap_arg_nearestPt unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_center = (unsafe.Pointer)(center)
	wrap_arg_halfExtents = (unsafe.Pointer)(halfExtents)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_arg_nearestRef = (unsafe.Pointer)(nearestRef)
	wrap_arg_nearestPt = (unsafe.Pointer)(nearestPt)
	wrap_out := C.nav_dtNavMeshQuery_findNearestPoly(wrap_this, wrap_arg_center, wrap_arg_halfExtents, wrap_arg_filter, wrap_arg_nearestRef, wrap_arg_nearestPt)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Finds the polygon nearest to the specified center point.
[opt] means the specified parameter can be a null pointer, in that case the output parameter will not be set.

@param center The center of the search box. [(x, y, z)]
@param halfExtents The search distance along each axis. [(x, y, z)]
@param filter The polygon filter to apply to the query.
@param nearestRef The reference id of the nearest polygon. Will be set to 0 if no polygon is found.
@param nearestPt The nearest point on the polygon. Unchanged if no polygon is found. [opt] [(x, y, z)]
@param isOverPoly Set to true if the point's XZ coordinate lies inside the polygon, false otherwise. Unchanged if no polygon is found. [opt]
@returns The status flags for the query.

public dtStatus findNearestPoly(float const * center, float const * halfExtents, dtQueryFilter const * filter, dtPolyRef * nearestRef, float * nearestPt, bool * isOverPoly) const
*/
func (p DtNavMeshQueryPtr) FindNearestPoly11(center *float32, halfExtents *float32, filter DtQueryFilterPtr, nearestRef *uint32, nearestPt *float32, isOverPoly *bool) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_center unsafe.Pointer
	var wrap_arg_halfExtents unsafe.Pointer
	var wrap_arg_filter unsafe.Pointer
	var wrap_arg_nearestRef unsafe.Pointer
	var wrap_arg_nearestPt unsafe.Pointer
	var wrap_arg_isOverPoly unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_center = (unsafe.Pointer)(center)
	wrap_arg_halfExtents = (unsafe.Pointer)(halfExtents)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_arg_nearestRef = (unsafe.Pointer)(nearestRef)
	wrap_arg_nearestPt = (unsafe.Pointer)(nearestPt)
	wrap_arg_isOverPoly = (unsafe.Pointer)(isOverPoly)
	wrap_out := C.nav_dtNavMeshQuery_findNearestPoly11(wrap_this, wrap_arg_center, wrap_arg_halfExtents, wrap_arg_filter, wrap_arg_nearestRef, wrap_arg_nearestPt, wrap_arg_isOverPoly)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Finds a path from the start polygon to the end polygon.

@param startRef The reference id of the start polygon.
@param endRef The reference id of the end polygon.
@param startPos A position within the start polygon. [(x, y, z)]
@param endPos A position within the end polygon. [(x, y, z)]
@param filter The polygon filter to apply to the query.
@param path An ordered list of polygon references representing the path. (Start to end.)
[(polyRef) * @p pathCount]
@param pathCount The number of polygons returned in the @p path array.
@param maxPath The maximum number of polygons the @p path array can hold. [Limit: >= 1]

public dtStatus findPath(dtPolyRef startRef, dtPolyRef endRef, float const * startPos, float const * endPos, dtQueryFilter const * filter, dtPolyRef * path, int * pathCount, int const maxPath) const
*/
func (p DtNavMeshQueryPtr) FindPath(startRef uint32, endRef uint32, startPos *float32, endPos *float32, filter DtQueryFilterPtr, path *uint32, pathCount *int32, maxPath int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_startRef C.uint
	var wrap_arg_endRef C.uint
	var wrap_arg_startPos unsafe.Pointer
	var wrap_arg_endPos unsafe.Pointer
	var wrap_arg_filter unsafe.Pointer
	var wrap_arg_path unsafe.Pointer
	var wrap_arg_pathCount unsafe.Pointer
	var wrap_arg_maxPath C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_startRef = (C.uint)(startRef)
	wrap_arg_endRef = (C.uint)(endRef)
	wrap_arg_startPos = (unsafe.Pointer)(startPos)
	wrap_arg_endPos = (unsafe.Pointer)(endPos)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_arg_path = (unsafe.Pointer)(path)
	wrap_arg_pathCount = (unsafe.Pointer)(pathCount)
	wrap_arg_maxPath = (C.int)(maxPath)
	wrap_out := C.nav_dtNavMeshQuery_findPath(wrap_this, wrap_arg_startRef, wrap_arg_endRef, wrap_arg_startPos, wrap_arg_endPos, wrap_arg_filter, wrap_arg_path, wrap_arg_pathCount, wrap_arg_maxPath)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Finds the polygons along the navigation graph that touch the specified circle.

@param startRef The reference id of the polygon where the search starts.
@param centerPos The center of the search circle. [(x, y, z)]
@param radius The radius of the search circle.
@param filter The polygon filter to apply to the query.
@param resultRef The reference ids of the polygons touched by the circle. [opt]
@param resultParent The reference ids of the parent polygons for each result.
Zero if a result polygon has no parent. [opt]
@param resultCost The search cost from @p centerPos to the polygon. [opt]
@param resultCount The number of polygons found. [opt]
@param maxResult The maximum number of polygons the result arrays can hold.
@returns The status flags for the query.

public dtStatus findPolysAroundCircle(dtPolyRef startRef, float const * centerPos, float const radius, dtQueryFilter const * filter, dtPolyRef * resultRef, dtPolyRef * resultParent, float * resultCost, int * resultCount, int const maxResult) const
*/
func (p DtNavMeshQueryPtr) FindPolysAroundCircle(startRef uint32, centerPos *float32, radius float32, filter DtQueryFilterPtr, resultRef *uint32, resultParent *uint32, resultCost *float32, resultCount *int32, maxResult int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_startRef C.uint
	var wrap_arg_centerPos unsafe.Pointer
	var wrap_arg_radius C.float
	var wrap_arg_filter unsafe.Pointer
	var wrap_arg_resultRef unsafe.Pointer
	var wrap_arg_resultParent unsafe.Pointer
	var wrap_arg_resultCost unsafe.Pointer
	var wrap_arg_resultCount unsafe.Pointer
	var wrap_arg_maxResult C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_startRef = (C.uint)(startRef)
	wrap_arg_centerPos = (unsafe.Pointer)(centerPos)
	wrap_arg_radius = (C.float)(radius)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_arg_resultRef = (unsafe.Pointer)(resultRef)
	wrap_arg_resultParent = (unsafe.Pointer)(resultParent)
	wrap_arg_resultCost = (unsafe.Pointer)(resultCost)
	wrap_arg_resultCount = (unsafe.Pointer)(resultCount)
	wrap_arg_maxResult = (C.int)(maxResult)
	wrap_out := C.nav_dtNavMeshQuery_findPolysAroundCircle(wrap_this, wrap_arg_startRef, wrap_arg_centerPos, wrap_arg_radius, wrap_arg_filter, wrap_arg_resultRef, wrap_arg_resultParent, wrap_arg_resultCost, wrap_arg_resultCount, wrap_arg_maxResult)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Finds the polygons along the naviation graph that touch the specified convex polygon.

@param startRef The reference id of the polygon where the search starts.
@param verts The vertices describing the convex polygon. (CCW)
[(x, y, z) * @p nverts]
@param nverts The number of vertices in the polygon.
@param filter The polygon filter to apply to the query.
@param resultRef The reference ids of the polygons touched by the search polygon. [opt]
@param resultParent The reference ids of the parent polygons for each result. Zero if a
result polygon has no parent. [opt]
@param resultCost The search cost from the centroid point to the polygon. [opt]
@param resultCount The number of polygons found.
@param maxResult The maximum number of polygons the result arrays can hold.
@returns The status flags for the query.

public dtStatus findPolysAroundShape(dtPolyRef startRef, float const * verts, int const nverts, dtQueryFilter const * filter, dtPolyRef * resultRef, dtPolyRef * resultParent, float * resultCost, int * resultCount, int const maxResult) const
*/
func (p DtNavMeshQueryPtr) FindPolysAroundShape(startRef uint32, verts *float32, nverts int32, filter DtQueryFilterPtr, resultRef *uint32, resultParent *uint32, resultCost *float32, resultCount *int32, maxResult int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_startRef C.uint
	var wrap_arg_verts unsafe.Pointer
	var wrap_arg_nverts C.int
	var wrap_arg_filter unsafe.Pointer
	var wrap_arg_resultRef unsafe.Pointer
	var wrap_arg_resultParent unsafe.Pointer
	var wrap_arg_resultCost unsafe.Pointer
	var wrap_arg_resultCount unsafe.Pointer
	var wrap_arg_maxResult C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_startRef = (C.uint)(startRef)
	wrap_arg_verts = (unsafe.Pointer)(verts)
	wrap_arg_nverts = (C.int)(nverts)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_arg_resultRef = (unsafe.Pointer)(resultRef)
	wrap_arg_resultParent = (unsafe.Pointer)(resultParent)
	wrap_arg_resultCost = (unsafe.Pointer)(resultCost)
	wrap_arg_resultCount = (unsafe.Pointer)(resultCount)
	wrap_arg_maxResult = (C.int)(maxResult)
	wrap_out := C.nav_dtNavMeshQuery_findPolysAroundShape(wrap_this, wrap_arg_startRef, wrap_arg_verts, wrap_arg_nverts, wrap_arg_filter, wrap_arg_resultRef, wrap_arg_resultParent, wrap_arg_resultCost, wrap_arg_resultCount, wrap_arg_maxResult)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Finds the straight path from the start to the end position within the polygon corridor.

@param startPos Path start position. [(x, y, z)]
@param endPos Path end position. [(x, y, z)]
@param path An array of polygon references that represent the path corridor.
@param pathSize The number of polygons in the @p path array.
@param straightPath Points describing the straight path. [(x, y, z) * @p straightPathCount].
@param straightPathFlags Flags describing each point. (See: #dtStraightPathFlags) [opt]
@param straightPathRefs The reference id of the polygon that is being entered at each point. [opt]
@param straightPathCount The number of points in the straight path.
@param maxStraightPath The maximum number of points the straight path arrays can hold.  [Limit: > 0]
@param options Query options. (see: #dtStraightPathOptions)
@returns The status flags for the query.

public dtStatus findStraightPath(float const * startPos, float const * endPos, dtPolyRef const * path, int const pathSize, float * straightPath, unsigned char * straightPathFlags, dtPolyRef * straightPathRefs, int * straightPathCount, int const maxStraightPath, int const options=0) const
*/
func (p DtNavMeshQueryPtr) FindStraightPath(startPos *float32, endPos *float32, path *uint32, pathSize int32, straightPath *float32, straightPathFlags *uint8, straightPathRefs *uint32, straightPathCount *int32, maxStraightPath int32, options int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_startPos unsafe.Pointer
	var wrap_arg_endPos unsafe.Pointer
	var wrap_arg_path unsafe.Pointer
	var wrap_arg_pathSize C.int
	var wrap_arg_straightPath unsafe.Pointer
	var wrap_arg_straightPathFlags unsafe.Pointer
	var wrap_arg_straightPathRefs unsafe.Pointer
	var wrap_arg_straightPathCount unsafe.Pointer
	var wrap_arg_maxStraightPath C.int
	var wrap_arg_options C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_startPos = (unsafe.Pointer)(startPos)
	wrap_arg_endPos = (unsafe.Pointer)(endPos)
	wrap_arg_path = (unsafe.Pointer)(path)
	wrap_arg_pathSize = (C.int)(pathSize)
	wrap_arg_straightPath = (unsafe.Pointer)(straightPath)
	wrap_arg_straightPathFlags = (unsafe.Pointer)(straightPathFlags)
	wrap_arg_straightPathRefs = (unsafe.Pointer)(straightPathRefs)
	wrap_arg_straightPathCount = (unsafe.Pointer)(straightPathCount)
	wrap_arg_maxStraightPath = (C.int)(maxStraightPath)
	wrap_arg_options = (C.int)(options)
	wrap_out := C.nav_dtNavMeshQuery_findStraightPath(wrap_this, wrap_arg_startPos, wrap_arg_endPos, wrap_arg_path, wrap_arg_pathSize, wrap_arg_straightPath, wrap_arg_straightPathFlags, wrap_arg_straightPathRefs, wrap_arg_straightPathCount, wrap_arg_maxStraightPath, wrap_arg_options)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Gets the navigation mesh the query object is using.

@return The navigation mesh the query object is using.

public dtNavMesh const * getAttachedNavMesh() const
*/
func (p DtNavMeshQueryPtr) GetAttachedNavMesh() DtNavMeshPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtNavMeshQuery_getAttachedNavMesh(wrap_this)
	go_out := cgo.MakePtr[DtNavMeshPtr](uintptr(wrap_out))
	return go_out
}

/*
Gets the node pool.

@returns The node pool.

public dtNodePool * getNodePool() const
*/
func (p DtNavMeshQueryPtr) GetNodePool() DtNodePoolPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtNavMeshQuery_getNodePool(wrap_this)
	go_out := cgo.MakePtr[DtNodePoolPtr](uintptr(wrap_out))
	return go_out
}

/*
Gets a path from the explored nodes in the previous search.

@param endRef The reference id of the end polygon.
@param path An ordered list of polygon references representing the path. (Start to end.)
[(polyRef) * @p pathCount]
@param pathCount The number of polygons returned in the @p path array.
@param maxPath The maximum number of polygons the @p path array can hold. [Limit: >= 0]
@returns The status flags. Returns DT_FAILURE | DT_INVALID_PARAM if any parameter is wrong, or if
@p endRef was not explored in the previous search. Returns DT_SUCCESS | DT_BUFFER_TOO_SMALL
if @p path cannot contain the entire path. In this case it is filled to capacity with a partial path.
Otherwise returns DT_SUCCESS.
@remarks The result of this function depends on the state of the query object. For that reason it should only
be used immediately after one of the two Dijkstra searches, findPolysAroundCircle or findPolysAroundShape.

public dtStatus getPathFromDijkstraSearch(dtPolyRef endRef, dtPolyRef * path, int * pathCount, int maxPath) const
*/
func (p DtNavMeshQueryPtr) GetPathFromDijkstraSearch(endRef uint32, path *uint32, pathCount *int32, maxPath int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_endRef C.uint
	var wrap_arg_path unsafe.Pointer
	var wrap_arg_pathCount unsafe.Pointer
	var wrap_arg_maxPath C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_endRef = (C.uint)(endRef)
	wrap_arg_path = (unsafe.Pointer)(path)
	wrap_arg_pathCount = (unsafe.Pointer)(pathCount)
	wrap_arg_maxPath = (C.int)(maxPath)
	wrap_out := C.nav_dtNavMeshQuery_getPathFromDijkstraSearch(wrap_this, wrap_arg_endRef, wrap_arg_path, wrap_arg_pathCount, wrap_arg_maxPath)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Gets the height of the polygon at the provided position using the height detail. (Most accurate.)

@param ref The reference id of the polygon.
@param pos A position within the xz-bounds of the polygon. [(x, y, z)]
@param height The height at the surface of the polygon.
@returns The status flags for the query.

public dtStatus getPolyHeight(dtPolyRef ref, float const * pos, float * height) const
*/
func (p DtNavMeshQueryPtr) GetPolyHeight(ref uint32, pos *float32, height *float32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_pos unsafe.Pointer
	var wrap_arg_height unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_pos = (unsafe.Pointer)(pos)
	wrap_arg_height = (unsafe.Pointer)(height)
	wrap_out := C.nav_dtNavMeshQuery_getPolyHeight(wrap_this, wrap_arg_ref, wrap_arg_pos, wrap_arg_height)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Returns the segments for the specified polygon, optionally including portals.

@param ref The reference id of the polygon.
@param filter The polygon filter to apply to the query.
@param segmentVerts The segments. [(ax, ay, az, bx, by, bz) * segmentCount]
@param segmentRefs The reference ids of each segment's neighbor polygon.
Or zero if the segment is a wall. [opt] [(parentRef) * @p segmentCount]
@param segmentCount The number of segments returned.
@param maxSegments The maximum number of segments the result arrays can hold.
@returns The status flags for the query.

public dtStatus getPolyWallSegments(dtPolyRef ref, dtQueryFilter const * filter, float * segmentVerts, dtPolyRef * segmentRefs, int * segmentCount, int const maxSegments) const
*/
func (p DtNavMeshQueryPtr) GetPolyWallSegments(ref uint32, filter DtQueryFilterPtr, segmentVerts *float32, segmentRefs *uint32, segmentCount *int32, maxSegments int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_filter unsafe.Pointer
	var wrap_arg_segmentVerts unsafe.Pointer
	var wrap_arg_segmentRefs unsafe.Pointer
	var wrap_arg_segmentCount unsafe.Pointer
	var wrap_arg_maxSegments C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_arg_segmentVerts = (unsafe.Pointer)(segmentVerts)
	wrap_arg_segmentRefs = (unsafe.Pointer)(segmentRefs)
	wrap_arg_segmentCount = (unsafe.Pointer)(segmentCount)
	wrap_arg_maxSegments = (C.int)(maxSegments)
	wrap_out := C.nav_dtNavMeshQuery_getPolyWallSegments(wrap_this, wrap_arg_ref, wrap_arg_filter, wrap_arg_segmentVerts, wrap_arg_segmentRefs, wrap_arg_segmentCount, wrap_arg_maxSegments)
	go_out := uint32(wrap_out)
	return go_out
}

/*
dtNavMeshQuery * IndexArray(long n)
*/
func (p DtNavMeshQueryPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtNavMeshQuery_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Initializes the query object.

@param nav Pointer to the dtNavMesh object to use for all queries.
@param maxNodes Maximum number of search nodes. [Limits: 0
<
value
<
= 65535]
@returns The status flags for the query.

public dtStatus init(dtNavMesh const * tmp_arg_nav, int const maxNodes)
*/
func (p DtNavMeshQueryPtr) Init(tmp_arg_nav DtNavMeshPtr, maxNodes int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_tmp_arg_nav unsafe.Pointer
	var wrap_arg_maxNodes C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_tmp_arg_nav = (unsafe.Pointer)(tmp_arg_nav)
	wrap_arg_maxNodes = (C.int)(maxNodes)
	wrap_out := C.nav_dtNavMeshQuery_init(wrap_this, wrap_arg_tmp_arg_nav, wrap_arg_maxNodes)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Initializes a sliced path query.

@param startRef The reference id of the start polygon.
@param endRef The reference id of the end polygon.
@param startPos A position within the start polygon. [(x, y, z)]
@param endPos A position within the end polygon. [(x, y, z)]
@param filter The polygon filter to apply to the query.
@param options query options (see: #dtFindPathOptions)
@returns The status flags for the query.

public dtStatus initSlicedFindPath(dtPolyRef startRef, dtPolyRef endRef, float const * startPos, float const * endPos, dtQueryFilter const * filter, unsigned int const options=0)
*/
func (p DtNavMeshQueryPtr) InitSlicedFindPath(startRef uint32, endRef uint32, startPos *float32, endPos *float32, filter DtQueryFilterPtr, options uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_startRef C.uint
	var wrap_arg_endRef C.uint
	var wrap_arg_startPos unsafe.Pointer
	var wrap_arg_endPos unsafe.Pointer
	var wrap_arg_filter unsafe.Pointer
	var wrap_arg_options C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_startRef = (C.uint)(startRef)
	wrap_arg_endRef = (C.uint)(endRef)
	wrap_arg_startPos = (unsafe.Pointer)(startPos)
	wrap_arg_endPos = (unsafe.Pointer)(endPos)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_arg_options = (C.uint)(options)
	wrap_out := C.nav_dtNavMeshQuery_initSlicedFindPath(wrap_this, wrap_arg_startRef, wrap_arg_endRef, wrap_arg_startPos, wrap_arg_endPos, wrap_arg_filter, wrap_arg_options)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Returns true if the polygon reference is in the closed list.

@param ref The reference id of the polygon to check.
@returns True if the polygon is in closed list.

public bool isInClosedList(dtPolyRef ref) const
*/
func (p DtNavMeshQueryPtr) IsInClosedList(ref uint32) bool {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_out := C.nav_dtNavMeshQuery_isInClosedList(wrap_this, wrap_arg_ref)
	go_out := bool(wrap_out)
	return go_out
}

/*
Returns true if the polygon reference is valid and passes the filter restrictions.

@param ref The polygon reference to check.
@param filter The filter to apply.

public bool isValidPolyRef(dtPolyRef ref, dtQueryFilter const * filter) const
*/
func (p DtNavMeshQueryPtr) IsValidPolyRef(ref uint32, filter DtQueryFilterPtr) bool {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_filter unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_out := C.nav_dtNavMeshQuery_isValidPolyRef(wrap_this, wrap_arg_ref, wrap_arg_filter)
	go_out := bool(wrap_out)
	return go_out
}

/*
Moves from the start to the end position constrained to the navigation mesh.

@param startRef The reference id of the start polygon.
@param startPos A position of the mover within the start polygon. [(x, y, x)]
@param endPos The desired end position of the mover. [(x, y, z)]
@param filter The polygon filter to apply to the query.
@param resultPos The result position of the mover. [(x, y, z)]
@param visited The reference ids of the polygons visited during the move.
@param visitedCount The number of polygons visited during the move.
@param maxVisitedSize The maximum number of polygons the @p visited array can hold.
@returns The status flags for the query.

public dtStatus moveAlongSurface(dtPolyRef startRef, float const * startPos, float const * endPos, dtQueryFilter const * filter, float * resultPos, dtPolyRef * visited, int * visitedCount, int const maxVisitedSize) const
*/
func (p DtNavMeshQueryPtr) MoveAlongSurface(startRef uint32, startPos *float32, endPos *float32, filter DtQueryFilterPtr, resultPos *float32, visited *uint32, visitedCount *int32, maxVisitedSize int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_startRef C.uint
	var wrap_arg_startPos unsafe.Pointer
	var wrap_arg_endPos unsafe.Pointer
	var wrap_arg_filter unsafe.Pointer
	var wrap_arg_resultPos unsafe.Pointer
	var wrap_arg_visited unsafe.Pointer
	var wrap_arg_visitedCount unsafe.Pointer
	var wrap_arg_maxVisitedSize C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_startRef = (C.uint)(startRef)
	wrap_arg_startPos = (unsafe.Pointer)(startPos)
	wrap_arg_endPos = (unsafe.Pointer)(endPos)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_arg_resultPos = (unsafe.Pointer)(resultPos)
	wrap_arg_visited = (unsafe.Pointer)(visited)
	wrap_arg_visitedCount = (unsafe.Pointer)(visitedCount)
	wrap_arg_maxVisitedSize = (C.int)(maxVisitedSize)
	wrap_out := C.nav_dtNavMeshQuery_moveAlongSurface(wrap_this, wrap_arg_startRef, wrap_arg_startPos, wrap_arg_endPos, wrap_arg_filter, wrap_arg_resultPos, wrap_arg_visited, wrap_arg_visitedCount, wrap_arg_maxVisitedSize)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Finds polygons that overlap the search box.

@param center The center of the search box. [(x, y, z)]
@param halfExtents The search distance along each axis. [(x, y, z)]
@param filter The polygon filter to apply to the query.
@param polys The reference ids of the polygons that overlap the query box.
@param polyCount The number of polygons in the search result.
@param maxPolys The maximum number of polygons the search result can hold.
@returns The status flags for the query.

public dtStatus queryPolygons(float const * center, float const * halfExtents, dtQueryFilter const * filter, dtPolyRef * polys, int * polyCount, int const maxPolys) const
*/
func (p DtNavMeshQueryPtr) QueryPolygons(center *float32, halfExtents *float32, filter DtQueryFilterPtr, polys *uint32, polyCount *int32, maxPolys int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_center unsafe.Pointer
	var wrap_arg_halfExtents unsafe.Pointer
	var wrap_arg_filter unsafe.Pointer
	var wrap_arg_polys unsafe.Pointer
	var wrap_arg_polyCount unsafe.Pointer
	var wrap_arg_maxPolys C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_center = (unsafe.Pointer)(center)
	wrap_arg_halfExtents = (unsafe.Pointer)(halfExtents)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_arg_polys = (unsafe.Pointer)(polys)
	wrap_arg_polyCount = (unsafe.Pointer)(polyCount)
	wrap_arg_maxPolys = (C.int)(maxPolys)
	wrap_out := C.nav_dtNavMeshQuery_queryPolygons(wrap_this, wrap_arg_center, wrap_arg_halfExtents, wrap_arg_filter, wrap_arg_polys, wrap_arg_polyCount, wrap_arg_maxPolys)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Finds polygons that overlap the search box.

@param center The center of the search box. [(x, y, z)]
@param halfExtents The search distance along each axis. [(x, y, z)]
@param filter The polygon filter to apply to the query.
@param query The query. Polygons found will be batched together and passed to this query.

public dtStatus queryPolygons(float const * center, float const * halfExtents, dtQueryFilter const * filter, dtPolyQuery * query) const
*/
func (p DtNavMeshQueryPtr) QueryPolygons11(center *float32, halfExtents *float32, filter DtQueryFilterPtr, query DtPolyQueryPtr) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_center unsafe.Pointer
	var wrap_arg_halfExtents unsafe.Pointer
	var wrap_arg_filter unsafe.Pointer
	var wrap_arg_query unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_center = (unsafe.Pointer)(center)
	wrap_arg_halfExtents = (unsafe.Pointer)(halfExtents)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_arg_query = (unsafe.Pointer)(query)
	wrap_out := C.nav_dtNavMeshQuery_queryPolygons11(wrap_this, wrap_arg_center, wrap_arg_halfExtents, wrap_arg_filter, wrap_arg_query)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Casts a 'walkability' ray along the surface of the navigation mesh from
the start position toward the end position.

@note A wrapper around raycast(..., RaycastHit*). Retained for backward compatibility.
@param startRef The reference id of the start polygon.
@param startPos A position within the start polygon representing
the start of the ray. [(x, y, z)]
@param endPos The position to cast the ray toward. [(x, y, z)]
@param filter The polygon filter to apply to the query.
@param t The hit parameter. (FLT_MAX if no wall hit.)
@param hitNormal The normal of the nearest wall hit. [(x, y, z)]
@param path The reference ids of the visited polygons. [opt]
@param pathCount The number of visited polygons. [opt]
@param maxPath The maximum number of polygons the @p path array can hold.
@returns The status flags for the query.

public dtStatus raycast(dtPolyRef startRef, float const * startPos, float const * endPos, dtQueryFilter const * filter, float * t, float * hitNormal, dtPolyRef * path, int * pathCount, int const maxPath) const
*/
func (p DtNavMeshQueryPtr) Raycast(startRef uint32, startPos *float32, endPos *float32, filter DtQueryFilterPtr, t *float32, hitNormal *float32, path *uint32, pathCount *int32, maxPath int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_startRef C.uint
	var wrap_arg_startPos unsafe.Pointer
	var wrap_arg_endPos unsafe.Pointer
	var wrap_arg_filter unsafe.Pointer
	var wrap_arg_t unsafe.Pointer
	var wrap_arg_hitNormal unsafe.Pointer
	var wrap_arg_path unsafe.Pointer
	var wrap_arg_pathCount unsafe.Pointer
	var wrap_arg_maxPath C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_startRef = (C.uint)(startRef)
	wrap_arg_startPos = (unsafe.Pointer)(startPos)
	wrap_arg_endPos = (unsafe.Pointer)(endPos)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_arg_t = (unsafe.Pointer)(t)
	wrap_arg_hitNormal = (unsafe.Pointer)(hitNormal)
	wrap_arg_path = (unsafe.Pointer)(path)
	wrap_arg_pathCount = (unsafe.Pointer)(pathCount)
	wrap_arg_maxPath = (C.int)(maxPath)
	wrap_out := C.nav_dtNavMeshQuery_raycast(wrap_this, wrap_arg_startRef, wrap_arg_startPos, wrap_arg_endPos, wrap_arg_filter, wrap_arg_t, wrap_arg_hitNormal, wrap_arg_path, wrap_arg_pathCount, wrap_arg_maxPath)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Casts a 'walkability' ray along the surface of the navigation mesh from
the start position toward the end position.

@param startRef The reference id of the start polygon.
@param startPos A position within the start polygon representing
the start of the ray. [(x, y, z)]
@param endPos The position to cast the ray toward. [(x, y, z)]
@param filter The polygon filter to apply to the query.
@param options govern how the raycast behaves. See dtRaycastOptions
@param hit Pointer to a raycast hit structure which will be filled by the results.
@param prevRef parent of start ref. Used during for cost calculation [opt]
@returns The status flags for the query.

public dtStatus raycast(dtPolyRef startRef, float const * startPos, float const * endPos, dtQueryFilter const * filter, unsigned int const options, dtRaycastHit * hit, dtPolyRef prevRef=0) const
*/
func (p DtNavMeshQueryPtr) Raycast11(startRef uint32, startPos *float32, endPos *float32, filter DtQueryFilterPtr, options uint32, hit DtRaycastHitPtr, prevRef uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_startRef C.uint
	var wrap_arg_startPos unsafe.Pointer
	var wrap_arg_endPos unsafe.Pointer
	var wrap_arg_filter unsafe.Pointer
	var wrap_arg_options C.uint
	var wrap_arg_hit unsafe.Pointer
	var wrap_arg_prevRef C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_startRef = (C.uint)(startRef)
	wrap_arg_startPos = (unsafe.Pointer)(startPos)
	wrap_arg_endPos = (unsafe.Pointer)(endPos)
	wrap_arg_filter = (unsafe.Pointer)(filter)
	wrap_arg_options = (C.uint)(options)
	wrap_arg_hit = (unsafe.Pointer)(hit)
	wrap_arg_prevRef = (C.uint)(prevRef)
	wrap_out := C.nav_dtNavMeshQuery_raycast11(wrap_this, wrap_arg_startRef, wrap_arg_startPos, wrap_arg_endPos, wrap_arg_filter, wrap_arg_options, wrap_arg_hit, wrap_arg_prevRef)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Updates an in-progress sliced path query.

@param maxIter The maximum number of iterations to perform.
@param doneIters The actual number of iterations completed. [opt]
@returns The status flags for the query.

public dtStatus updateSlicedFindPath(int const maxIter, int * doneIters)
*/
func (p DtNavMeshQueryPtr) UpdateSlicedFindPath(maxIter int32, doneIters *int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_maxIter C.int
	var wrap_arg_doneIters unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_maxIter = (C.int)(maxIter)
	wrap_arg_doneIters = (unsafe.Pointer)(doneIters)
	wrap_out := C.nav_dtNavMeshQuery_updateSlicedFindPath(wrap_this, wrap_arg_maxIter, wrap_arg_doneIters)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Provides custom polygon query behavior.
Used by dtNavMeshQuery::queryPolygons.

	detour
*/
type DtPolyQueryPtr uintptr

/*
public virtual void Delete()
*/
func (p DtPolyQueryPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtPolyQuery_Delete(wrap_this)
}

/*
Called for each batch of unique polygons touched by the search area in dtNavMeshQuery::queryPolygons.
This can be called multiple times for a single query.

public virtual void process(dtMeshTile const * tile, dtPoly * * polys, dtPolyRef * refs, int count) = 0
*/
func (p DtPolyQueryPtr) Process(tile DtMeshTilePtr, polys *DtPolyPtr, refs *uint32, count int32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_tile unsafe.Pointer
	var wrap_arg_polys unsafe.Pointer
	var wrap_arg_refs unsafe.Pointer
	var wrap_arg_count C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_tile = (unsafe.Pointer)(tile)
	wrap_arg_polys = (unsafe.Pointer)(polys)
	wrap_arg_refs = (unsafe.Pointer)(refs)
	wrap_arg_count = (C.int)(count)
	C.nav_dtPolyQuery_process(wrap_this, wrap_arg_tile, wrap_arg_polys, wrap_arg_refs, wrap_arg_count)
}

/*
Defines polygon filtering and traversal costs for navigation mesh query operations.

	detour
*/
type DtQueryFilterPtr uintptr

/*
public virtual void Delete()
*/
func (p DtQueryFilterPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtQueryFilter_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtQueryFilterPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtQueryFilter_DeleteArray(wrap_this)
}

/*
public dtQueryFilter()
*/
func NewDtQueryFilter() cgo.GoManagedPtr[DtQueryFilterPtr] {
	wrap_out := C.nav_NewdtQueryFilter()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtQueryFilterPtr]](uintptr(wrap_out))
	return go_out
}

/*
Returns the traversal cost of the area.

@param i The id of the area.
@returns The traversal cost of the area.

public float getAreaCost(int const i) const
*/
func (p DtQueryFilterPtr) GetAreaCost(i int32) float32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_i C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_i = (C.int)(i)
	wrap_out := C.nav_dtQueryFilter_getAreaCost(wrap_this, wrap_arg_i)
	go_out := float32(wrap_out)
	return go_out
}

/*
public virtual float getCost(float const * pa, float const * pb, dtPolyRef const prevRef, dtMeshTile const * prevTile, dtPoly const * prevPoly, dtPolyRef const curRef, dtMeshTile const * curTile, dtPoly const * curPoly, dtPolyRef const nextRef, dtMeshTile const * nextTile, dtPoly const * nextPoly) const
*/
func (p DtQueryFilterPtr) GetCost(pa *float32, pb *float32, prevRef uint32, prevTile DtMeshTilePtr, prevPoly DtPolyPtr, curRef uint32, curTile DtMeshTilePtr, curPoly DtPolyPtr, nextRef uint32, nextTile DtMeshTilePtr, nextPoly DtPolyPtr) float32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_pa unsafe.Pointer
	var wrap_arg_pb unsafe.Pointer
	var wrap_arg_prevRef C.uint
	var wrap_arg_prevTile unsafe.Pointer
	var wrap_arg_prevPoly unsafe.Pointer
	var wrap_arg_curRef C.uint
	var wrap_arg_curTile unsafe.Pointer
	var wrap_arg_curPoly unsafe.Pointer
	var wrap_arg_nextRef C.uint
	var wrap_arg_nextTile unsafe.Pointer
	var wrap_arg_nextPoly unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_pa = (unsafe.Pointer)(pa)
	wrap_arg_pb = (unsafe.Pointer)(pb)
	wrap_arg_prevRef = (C.uint)(prevRef)
	wrap_arg_prevTile = (unsafe.Pointer)(prevTile)
	wrap_arg_prevPoly = (unsafe.Pointer)(prevPoly)
	wrap_arg_curRef = (C.uint)(curRef)
	wrap_arg_curTile = (unsafe.Pointer)(curTile)
	wrap_arg_curPoly = (unsafe.Pointer)(curPoly)
	wrap_arg_nextRef = (C.uint)(nextRef)
	wrap_arg_nextTile = (unsafe.Pointer)(nextTile)
	wrap_arg_nextPoly = (unsafe.Pointer)(nextPoly)
	wrap_out := C.nav_dtQueryFilter_getCost(wrap_this, wrap_arg_pa, wrap_arg_pb, wrap_arg_prevRef, wrap_arg_prevTile, wrap_arg_prevPoly, wrap_arg_curRef, wrap_arg_curTile, wrap_arg_curPoly, wrap_arg_nextRef, wrap_arg_nextTile, wrap_arg_nextPoly)
	go_out := float32(wrap_out)
	return go_out
}

/*
Returns the exclude flags for the filter.
Any polygons that include one ore more of these flags will be
excluded from the operation.

public unsigned short getExcludeFlags() const
*/
func (p DtQueryFilterPtr) GetExcludeFlags() uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtQueryFilter_getExcludeFlags(wrap_this)
	go_out := uint16(wrap_out)
	return go_out
}

/*
Returns the include flags for the filter.
Any polygons that include one or more of these flags will be
included in the operation.

public unsigned short getIncludeFlags() const
*/
func (p DtQueryFilterPtr) GetIncludeFlags() uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtQueryFilter_getIncludeFlags(wrap_this)
	go_out := uint16(wrap_out)
	return go_out
}

/*
dtQueryFilter * IndexArray(long n)
*/
func (p DtQueryFilterPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtQueryFilter_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public virtual bool passFilter(dtPolyRef const ref, dtMeshTile const * tile, dtPoly const * poly) const
*/
func (p DtQueryFilterPtr) PassFilter(ref uint32, tile DtMeshTilePtr, poly DtPolyPtr) bool {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_tile unsafe.Pointer
	var wrap_arg_poly unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_tile = (unsafe.Pointer)(tile)
	wrap_arg_poly = (unsafe.Pointer)(poly)
	wrap_out := C.nav_dtQueryFilter_passFilter(wrap_this, wrap_arg_ref, wrap_arg_tile, wrap_arg_poly)
	go_out := bool(wrap_out)
	return go_out
}

/*
Sets the traversal cost of the area.

@param i The id of the area.
@param cost The new cost of traversing the area.

public void setAreaCost(int const i, float const cost)
*/
func (p DtQueryFilterPtr) SetAreaCost(i int32, cost float32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_i C.int
	var wrap_arg_cost C.float
	wrap_this = unsafe.Pointer(p)
	wrap_arg_i = (C.int)(i)
	wrap_arg_cost = (C.float)(cost)
	C.nav_dtQueryFilter_setAreaCost(wrap_this, wrap_arg_i, wrap_arg_cost)
}

/*
Sets the exclude flags for the filter.

@param flags The new flags.

public void setExcludeFlags(unsigned short const flags)
*/
func (p DtQueryFilterPtr) SetExcludeFlags(flags uint16) {
	var wrap_this unsafe.Pointer
	var wrap_arg_flags C.ushort
	wrap_this = unsafe.Pointer(p)
	wrap_arg_flags = (C.ushort)(flags)
	C.nav_dtQueryFilter_setExcludeFlags(wrap_this, wrap_arg_flags)
}

/*
Sets the include flags for the filter.

@param flags The new flags.

public void setIncludeFlags(unsigned short const flags)
*/
func (p DtQueryFilterPtr) SetIncludeFlags(flags uint16) {
	var wrap_this unsafe.Pointer
	var wrap_arg_flags C.ushort
	wrap_this = unsafe.Pointer(p)
	wrap_arg_flags = (C.ushort)(flags)
	C.nav_dtQueryFilter_setIncludeFlags(wrap_this, wrap_arg_flags)
}

/*
Provides information about raycast hit
filled by dtNavMeshQuery::raycast

	detour
*/
type DtRaycastHitPtr uintptr

/*
public void Delete()
*/
func (p DtRaycastHitPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtRaycastHit_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtRaycastHitPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtRaycastHit_DeleteArray(wrap_this)
}

/*
public dtRaycastHit()
*/
func NewDtRaycastHit() cgo.GoManagedPtr[DtRaycastHitPtr] {
	wrap_out := C.nav_NewdtRaycastHit()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtRaycastHitPtr]](uintptr(wrap_out))
	return go_out
}

/*
The index of the edge on the final polygon where the wall was hit.

public int * GetPtrToHitEdgeIndex()
*/
func (p DtRaycastHitPtr) GetPtrToHitEdgeIndex() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtRaycastHit_GetPtrToHitEdgeIndex(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
hitNormal	The normal of the nearest wall hit. [(x, y, z)]

public float(*)[3] GetPtrToHitNormal()
*/
func (p DtRaycastHitPtr) GetPtrToHitNormal() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtRaycastHit_GetPtrToHitNormal(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum number of polygons the @p path array can hold.

public int * GetPtrToMaxPath()
*/
func (p DtRaycastHitPtr) GetPtrToMaxPath() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtRaycastHit_GetPtrToMaxPath(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Pointer to an array of reference ids of the visited polygons. [opt]

public dtPolyRef * * GetPtrToPath()
*/
func (p DtRaycastHitPtr) GetPtrToPath() **uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtRaycastHit_GetPtrToPath(wrap_this)
	go_out := (**uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The cost of the path until hit.

public float * GetPtrToPathCost()
*/
func (p DtRaycastHitPtr) GetPtrToPathCost() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtRaycastHit_GetPtrToPathCost(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of visited polygons. [opt]

public int * GetPtrToPathCount()
*/
func (p DtRaycastHitPtr) GetPtrToPathCount() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtRaycastHit_GetPtrToPathCount(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The hit parameter. (FLT_MAX if no wall hit.)

public float * GetPtrToT()
*/
func (p DtRaycastHitPtr) GetPtrToT() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtRaycastHit_GetPtrToT(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtRaycastHit * IndexArray(long n)
*/
func (p DtRaycastHitPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtRaycastHit_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Allocates a query object using the Detour allocator.

@return An allocated query object, or null on failure.

	detour

dtNavMeshQuery * dtAllocNavMeshQuery()
*/
func DtAllocNavMeshQuery() DtNavMeshQueryPtr {
	wrap_out := C.nav_dtAllocNavMeshQuery()
	go_out := cgo.MakePtr[DtNavMeshQueryPtr](uintptr(wrap_out))
	return go_out
}

/*
Frees the specified query object using the Detour allocator.

@param query A query object allocated using #dtAllocNavMeshQuery

	detour

void dtFreeNavMeshQuery(dtNavMeshQuery * query)
*/
func DtFreeNavMeshQuery(query DtNavMeshQueryPtr) {
	var wrap_arg_query unsafe.Pointer
	wrap_arg_query = (unsafe.Pointer)(query)
	C.nav_dtFreeNavMeshQuery(wrap_arg_query)
}

/*
dtNavMeshQuery * NewDtNavMeshQueryPtrArray(long n)
*/
func NewDtNavMeshQueryPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtNavMeshQueryPtr]] {
	wrap_out := C.nav_NewDtNavMeshQueryPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtNavMeshQueryPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtQueryFilter * NewDtQueryFilterPtrArray(long n)
*/
func NewDtQueryFilterPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtQueryFilterPtr]] {
	wrap_out := C.nav_NewDtQueryFilterPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtQueryFilterPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtRaycastHit * NewDtRaycastHitPtrArray(long n)
*/
func NewDtRaycastHitPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtRaycastHitPtr]] {
	wrap_out := C.nav_NewDtRaycastHitPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtRaycastHitPtr]]](uintptr(wrap_out))
	return go_out
}
